﻿window.vartop = 20;

window.easymde = null;


if (window.layui) {
	layui.config({
		base: "/lib/easymde-layui/mods/",
	}).extend({
		easymde: 'easymde/easymde',
	});


	var markdown = function () {
		layui.use(["easymde"], function () {
			const $ = layui.$;
			var easymde = layui.easymde;
			window.easymde = layui.easymde;
			window.easymde.init({
				element: document.getElementById("detail"), //文本域ID
				autosave: {
					enabled: false, //开启自动保存
					uniqueId: "MyUniqueID", //唯一ID值，通过唯一ID值进行保存编写记录
					delay: 1000, //多少毫秒保存一次
				},
				initialValue: " ",

				promptURLs: true, // 如果设置为true，则会显示一个JS警报窗口，要求提供链接或图像URL。默认为false。
				renderingConfig: {
					codeSyntaxHighlighting: true, //开启代码高亮
				},
				placeholder: "|",
				//status: ["autosave", "lines", "words","cursor"], //设置为false 则禁用状态栏 默认为true 开启所有
				toolbar: [
					//展示所有工具栏,如果不指定有默认的选项。
					"bold", //黑体
					"strikethrough", //删除线
					"|", //分割线
					"code", // 代码块
					"quote", //引用
					"|", //分割线
					"unordered-list", // 无序列表
					"ordered-list", // 有序列表
					"|", //分割线
					"preview"
				],
				upload: {
					url: location.host.indexOf("janjanle.com") > -1 ? "http://gateway.janjanle.com/storage" : "https://gateway.itool.store/storage",
				}
			});


			var uploadFile = function (simplemde, fileName, formData, isImage) {
				return $.ajax({
					url: location.host.indexOf("janjanle.com") > -1 ? "http://gateway.janjanle.com/storage" : "https://gateway.itool.store/storage",
					type: 'post',
					data: formData,
					contentType: false,
					processData: false,
					success: function (res) {
						if (res.id) {
							let url = (isImage ? '!' : '') + '[' + (isImage ? '' : 'download ') + res.name + '](' + (location.host.indexOf("janjanle.com") > -1 ? "http://gateway.janjanle.com" : "https://gateway.itool.store") + '/storage/' + res.id + (isImage ? '/view)' : ')');
							let content = simplemde.getValue()
							simplemde.setValue(content + url + '\n')
						} else {
							layer.msg("文件上传失败", {
								icon: 5,
							});
						}
					},
					error: function () {
						layer.msg("上传 [" + fileName + "] 发生错误, 不支持文件夹上传");
					}
				})
			}

			var onCheckUploadEvent = function (isClipboard, e) {
				var isSupport = false;

				if (isClipboard) {
					isSupport = e.clipboardData && e.clipboardData.items;
				} else {
					isSupport = e.dataTransfer && e.dataTransfer.files;
				}

				if (!isSupport) {
					return
				}

				let dataList = isClipboard ? e.clipboardData.items : e.dataTransfer.files;

				try {

					var fileInfos = []

					for (var i = 0; i < dataList.length; i++) {
						var file = isClipboard ? dataList[i].getAsFile() : dataList[i];
						if (file) {
							fileInfos.push(file)
						}
					}

					if (fileInfos.length) {
						e.preventDefault()
						layer.confirm(fileInfos.map(a => a.name).join('<br />'),
							{
								btn: ['确认', '取消'], //按钮
								title: "上传粘贴板文件"
							}, function (index) {
								layer.close(index);

								if (fileInfos.length > 2) {
									layer.msg("每次最多上传2个文件");
									return;
								}

								index = layer.load(1);

								var uploadFileRequestList = []

								try {
									for (var i = 0; i < fileInfos.length; i++) {
										var fileInfo = fileInfos[i];
										//console.log(fileInfo)
										let formData = new FormData()
										formData.append('file', fileInfo, fileInfo.name)

										// image max 512 kb
										// other max 2MB
										var maxSize = fileInfo.type.indexOf('image') !== -1 ? 512 : 2048;

										if ((fileInfo.size / 1024) <= maxSize) {
											var request = uploadFile(easymde.codemirror, fileInfo.name, formData, maxSize == 512)
											uploadFileRequestList.push(request);
										} else {
											if (maxSize == 512) {
												layer.msg("上传图片大小不可超过 512Kb,建议使用截图工具剪贴后上传");
											} else {
												layer.msg("上传文件大小不可超过 2Mb");
											}
										}
									}
									Promise.all(uploadFileRequestList).then(res => {
										layer.close(index);
									}).catch(error => {
										layer.close(index);
									});
								} catch (e) {
									layer.close(index);
									layer.msg("上传发生错误，请重试");
								}
							}, function () {
								// 取消
							});
					}

				} catch (e) {
					// 弹窗说明，只能粘贴图片
				}
			}

			if (easymde.codemirror) {
				easymde.codemirror.on('paste', (editor, e) => onCheckUploadEvent(true, e))
				easymde.codemirror.on('drop', (editor, e) => onCheckUploadEvent(false, e))
			}
			
		});
	}

	markdown();
}

var htmlFormat = function (text) {
	var isHtml = text.indexOf('<p>') > -1;
	text = text.replace(/<div (.*?)>/gi, " ");
	text = text.replace(/<div>/gi, " ");
	text = text.replace(/<span (.*?)>/gi, "");
	text = text.replace(/<span>/gi, "");
	text = text.replace(/<\/span>/gi, " ");
	text = text.replace(/<pre (.*?)>/gi, "");
	text = text.replace(/<pre>/gi, "");
	text = text.replace(/<\/pre>/gi, " ");
	text = text.replace(/<p> #/g, " \n#");
	text = text.replace(/<p>#/g, " \n#");
	text = text.replace(/<p>/g, "\n");
	text = text.replace(/<\/div>/gi, "\n");
	text = text.replace(/<\/p>/g, "\n");
	text = text.replace(/<br \/>/g, "\n");
	text = text.replace(/<br\/>/g, "\n");
	text = text.replace(/<br>/g, "\n");
	text = text.replace(/&nbsp;/g, " ");
	text = text.replace(/& gt;/g, "&gt;");
	text = text.replace(/& lt;/g, "&lt;");
	text = text.replace(/&gt;/g, ">");
	text = text.replace(/&lt;/g, "<");
	if (isHtml) text = text.replace(/\n\n/g, "\n");
	return text;
}

var gtAndlt = function (value) {
	value = value.replace(/& gt;/g, "&gt;");
	value = value.replace(/& lt;/g, "&lt;");
	value = value.replace(/&gt;/g, ">");
	value = value.replace(/&lt;/g, "<");
	return value;
}

window.onload = function () {

	var converter = new showdown.Converter();
	converter.setOption("tables", true);
	// console.log('window.detailContent', window.detailContent)

	if (window.detailContent) {
		var text = htmlFormat(window.detailContent.replace(/··\*/g, '`'));

		$('.post-body').html(window.easymde.html(text));

		//$('.post-body').html(converter.makeHtml(text));

		//if (checkHtml(window.detailContent)) {
		//	$('.post-body').html(converter.makeHtml(text));
		//} else {
		//	$('.post-body').html(converter.makeHtml(text).replace(/\n/g, "<br />"));
		//}
	}
	
	
	$(".comment-body").each(function (i, item) {
		var itemComment = $(item).html();
		var value = htmlFormat(itemComment);
		$(item).html(window.easymde.html(value));
	});

	let parts = {};

	$('.post-body').find("h1,h2,h3,h4,h5,h6").each(function (i, item) {
		var tag = $(item).get(0).localName;
		$(item).attr("id", "wow" + i);
		parts[i] = 'wow' + i + '';
		$("#nav-fixed").append('<a class="menuItem new' + tag + (i == 0 ? " active" : "") + '" href="#wow' + i + '">' + $(this).text() + '</a>');
		$(".newh1").css("margin-left", 0);
		$(".newh2").css("margin-left", 20);
		$(".newh3").css("margin-left", 40);
		$(".newh4").css("margin-left", 60);
		$(".newh5").css("margin-left", 80);
		$(".newh6").css("margin-left", 100);
	});

	$("code").each(function () {
		var decoder = new JsDecoder();
		var that = $(this);
		var code = that.html();

		let reg = /<\/?.+?\/?>/g;
		var value = code.replace(reg, '');
		value = gtAndlt(value)
		value = decoder.decode(value);
		that.html(value);

		//var tabchar = ' ';
		//var regEmptyTag = /(<([^\/][^>|^\/>].*)>)(\s*)?(<\/([^>]*)>)/g;
		//var c = js_beautify(js_source, 4, tabchar);

		//c = c.replace(/& nbsp;/g, "&nbsp;");
		//c = c.replace(/& gt;/g, "&gt;");
		//c = c.replace(/&gt;\n/g, "&gt;");
		//c = c.replace(/& lt;\n/g, "&lt;");

		////console.log(c.replace(regEmptyTag, '$1$4'))

		//that.html(c.replace(regEmptyTag, '$1$4'));
	});

	hljs.initHighlighting();
	//$('pre code').each(function (i, block) {
	//	hljs.highlightBlock(block);
	//});

	this.setTimeout(function () {

		if ($('#left_nav').length) {
			$('#left_nav').stickUp({
				itemClass: 'menuItem',
				itemHover: 'active',
				marginTop: '20px'
			});
		}
		

		if (!$('.post-body').find("h1,h2,h3,h4,h5,h6").length) {
			$("#category").remove();
		} else {
			jQuery(function ($) {
				$('#nav-fixed').stickUp({
					parts: parts,
					itemClass: 'menuItem',
					itemHover: 'active',
					marginTop: '20px'
				});
			});
		}
	}, 600);
}






function js_beautify(js_source_text, indent_size, indent_character, indent_level) {

	var input, output, token_text, last_type, last_text, last_word, current_mode, modes, indent_string;
	var whitespace, wordchar, punct, parser_pos, line_starters, in_case;
	var prefix, token_type, do_block_just_closed, var_line, var_line_tainted;



	function trim_output() {
		while (output.length && (output[output.length - 1] === ' ' || output[output.length - 1] === indent_string)) {
			output.pop();
		}
	}

	function print_newline(ignore_repeated) {
		ignore_repeated = typeof ignore_repeated === 'undefined' ? true : ignore_repeated;

		trim_output();

		if (!output.length) {
			return; // no newline on start of file
		}

		if (output[output.length - 1] !== "\n" || !ignore_repeated) {
			output.push("\n");
		}
		for (var i = 0; i < indent_level; i++) {
			output.push(indent_string);
		}
	}



	function print_space() {
		var last_output = output.length ? output[output.length - 1] : ' ';
		if (last_output !== ' ' && last_output !== '\n' && last_output !== indent_string) { // prevent occassional duplicate space
			output.push(' ');
		}
	}


	function print_token() {
		output.push(token_text);
	}

	function indent() {
		indent_level++;
	}


	function unindent() {
		if (indent_level) {
			indent_level--;
		}
	}


	function remove_indent() {
		if (output.length && output[output.length - 1] === indent_string) {
			output.pop();
		}
	}


	function set_mode(mode) {
		modes.push(current_mode);
		current_mode = mode;
	}


	function restore_mode() {
		do_block_just_closed = current_mode === 'DO_BLOCK';
		current_mode = modes.pop();
	}


	function in_array(what, arr) {
		for (var i = 0; i < arr.length; i++) {
			if (arr[i] === what) {
				return true;
			}
		}
		return false;
	}



	function get_next_token() {
		var n_newlines = 0;
		var c = '';

		do {
			if (!input) {
				return ['', 'TK_EOF'];
			}
			if (parser_pos >= input.length) {
				return ['', 'TK_EOF'];
			}
			c = input.charAt(parser_pos);

			parser_pos += 1;
			if (c === "\n") {
				n_newlines += 1;
			}
		}
		while (in_array(c, whitespace));

		if (n_newlines > 1) {
			for (var i = 0; i < 2; i++) {
				print_newline(i === 0);
			}
		}
		var wanted_newline = (n_newlines === 1);


		if (in_array(c, wordchar)) {
			if (parser_pos < input.length) {
				while (in_array(input.charAt(parser_pos), wordchar)) {
					c += input.charAt(parser_pos);
					parser_pos += 1;
					if (parser_pos === input.length) {
						break;
					}
				}
			}

			// small and surprisingly unugly hack for 1E-10 representation
			if (parser_pos !== input.length && c.match(/^[0-9]+[Ee]$/) && input.charAt(parser_pos) === '-') {
				parser_pos += 1;

				var t = get_next_token(parser_pos);
				c += '-' + t[0];
				return [c, 'TK_WORD'];
			}

			if (c === 'in') { // hack for 'in' operator
				return [c, 'TK_OPERATOR'];
			}
			return [c, 'TK_WORD'];
		}

		if (c === '(' || c === '[') {
			return [c, 'TK_START_EXPR'];
		}

		if (c === ')' || c === ']') {
			return [c, 'TK_END_EXPR'];
		}

		if (c === '{') {
			return [c, 'TK_START_BLOCK'];
		}

		if (c === '}') {
			return [c, 'TK_END_BLOCK'];
		}

		if (c === ';') {
			return [c, 'TK_END_COMMAND'];
		}

		if (c === '/') {
			var comment = '';
			// peek for comment /* ... */
			if (input.charAt(parser_pos) === '*') {
				parser_pos += 1;
				if (parser_pos < input.length) {
					while (!(input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/') && parser_pos < input.length) {
						comment += input.charAt(parser_pos);
						parser_pos += 1;
						if (parser_pos >= input.length) {
							break;
						}
					}
				}
				parser_pos += 2;
				return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT'];
			}
			// peek for comment // ...
			if (input.charAt(parser_pos) === '/') {
				comment = c;
				while (input.charAt(parser_pos) !== "\x0d" && input.charAt(parser_pos) !== "\x0a") {
					comment += input.charAt(parser_pos);
					parser_pos += 1;
					if (parser_pos >= input.length) {
						break;
					}
				}
				parser_pos += 1;
				if (wanted_newline) {
					print_newline();
				}
				return [comment, 'TK_COMMENT'];
			}

		}

		if (c === "'" || // string
			c === '"' || // string
			(c === '/' &&
				((last_type === 'TK_WORD' && last_text === 'return') || (last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || last_type === 'TK_OPERATOR' || last_type === 'TK_EOF' || last_type === 'TK_END_COMMAND')))) { // regexp
			var sep = c;
			var esc = false;
			c = '';

			if (parser_pos < input.length) {

				while (esc || input.charAt(parser_pos) !== sep) {
					c += input.charAt(parser_pos);
					if (!esc) {
						esc = input.charAt(parser_pos) === '\\';
					} else {
						esc = false;
					}
					parser_pos += 1;
					if (parser_pos >= input.length) {
						break;
					}
				}

			}

			parser_pos += 1;
			if (last_type === 'TK_END_COMMAND') {
				print_newline();
			}
			return [sep + c + sep, 'TK_STRING'];
		}

		if (in_array(c, punct)) {
			while (parser_pos < input.length && in_array(c + input.charAt(parser_pos), punct)) {
				c += input.charAt(parser_pos);
				parser_pos += 1;
				if (parser_pos >= input.length) {
					break;
				}
			}
			return [c, 'TK_OPERATOR'];
		}

		return [c, 'TK_UNKNOWN'];
	}


	//----------------------------------

	indent_character = indent_character || ' ';
	indent_size = indent_size || 4;

	indent_string = '';
	while (indent_size--) {
		indent_string += indent_character;
	}

	input = js_source_text;

	last_word = ''; // last 'TK_WORD' passed
	last_type = 'TK_START_EXPR'; // last token type
	last_text = ''; // last token text
	output = [];

	do_block_just_closed = false;
	var_line = false;
	var_line_tainted = false;

	whitespace = "\n\r\t ".split('');
	wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split('');
	punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |='.split(' ');

	// words which should always start on new line.
	line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',');

	// states showing if we are currently in expression (i.e. "if" case) - 'EXPRESSION', or in usual block (like, procedure), 'BLOCK'.
	// some formatting depends on that.
	current_mode = 'BLOCK';
	modes = [current_mode];

	indent_level = indent_level || 0;
	parser_pos = 0; // parser position
	in_case = false; // flag for parser that case/default has been processed, and next colon needs special attention
	while (true) {
		var t = get_next_token(parser_pos);
		token_text = t[0];
		token_type = t[1];
		if (token_type === 'TK_EOF') {
			break;
		}

		switch (token_type) {

			case 'TK_START_EXPR':
				var_line = false;
				set_mode('EXPRESSION');
				if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR') {
					// do nothing on (( and )( and ][ and ]( ..
				} else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
					print_space();
				} else if (in_array(last_word, line_starters) && last_word !== 'function') {
					print_space();
				}
				print_token();
				break;

			case 'TK_END_EXPR':
				print_token();
				restore_mode();
				break;

			case 'TK_START_BLOCK':

				if (last_word === 'do') {
					set_mode('DO_BLOCK');
				} else {
					set_mode('BLOCK');
				}
				if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
					if (last_type === 'TK_START_BLOCK') {
						print_newline();
					} else {
						print_space();
					}
				}
				print_token();
				indent();
				break;

			case 'TK_END_BLOCK':
				if (last_type === 'TK_START_BLOCK') {
					// nothing
					trim_output();
					unindent();
				} else {
					unindent();
					print_newline();
				}
				print_token();
				restore_mode();
				break;

			case 'TK_WORD':

				if (do_block_just_closed) {
					print_space();
					print_token();
					print_space();
					break;
				}

				if (token_text === 'case' || token_text === 'default') {
					if (last_text === ':') {
						// switch cases following one another
						remove_indent();
					} else {
						// case statement starts in the same line where switch
						unindent();
						print_newline();
						indent();
					}
					print_token();
					in_case = true;
					break;
				}


				prefix = 'NONE';
				if (last_type === 'TK_END_BLOCK') {
					if (!in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
						prefix = 'NEWLINE';
					} else {
						prefix = 'SPACE';
						print_space();
					}
				} else if (last_type === 'TK_END_COMMAND' && (current_mode === 'BLOCK' || current_mode === 'DO_BLOCK')) {
					prefix = 'NEWLINE';
				} else if (last_type === 'TK_END_COMMAND' && current_mode === 'EXPRESSION') {
					prefix = 'SPACE';
				} else if (last_type === 'TK_WORD') {
					prefix = 'SPACE';
				} else if (last_type === 'TK_START_BLOCK') {
					prefix = 'NEWLINE';
				} else if (last_type === 'TK_END_EXPR') {
					print_space();
					prefix = 'NEWLINE';
				}

				if (last_type !== 'TK_END_BLOCK' && in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
					print_newline();
				} else if (in_array(token_text, line_starters) || prefix === 'NEWLINE') {
					if (last_text === 'else') {
						// no need to force newline on else break
						print_space();
					} else if ((last_type === 'TK_START_EXPR' || last_text === '=') && token_text === 'function') {
						// no need to force newline on 'function': (function
						// DONOTHING
					} else if (last_type === 'TK_WORD' && (last_text === 'return' || last_text === 'throw')) {
						// no newline between 'return nnn'
						print_space();
					} else if (last_type !== 'TK_END_EXPR') {
						if ((last_type !== 'TK_START_EXPR' || token_text !== 'var') && last_text !== ':') {
							// no need to force newline on 'var': for (var x = 0...)
							if (token_text === 'if' && last_type === 'TK_WORD' && last_word === 'else') {
								// no newline for } else if {
								print_space();
							} else {
								print_newline();
							}
						}
					} else {
						if (in_array(token_text, line_starters) && last_text !== ')') {
							print_newline();
						}
					}
				} else if (prefix === 'SPACE') {
					print_space();
				}
				print_token();
				last_word = token_text;

				if (token_text === 'var') {
					var_line = true;
					var_line_tainted = false;
				}

				break;

			case 'TK_END_COMMAND':

				print_token();
				var_line = false;
				break;

			case 'TK_STRING':

				if (last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK') {
					print_newline();
				} else if (last_type === 'TK_WORD') {
					print_space();
				}
				print_token();
				break;

			case 'TK_OPERATOR':

				var start_delim = true;
				var end_delim = true;
				if (var_line && token_text !== ',') {
					var_line_tainted = true;
					if (token_text === ':') {
						var_line = false;
					}
				}

				if (token_text === ':' && in_case) {
					print_token(); // colon really asks for separate treatment
					print_newline();
					break;
				}

				in_case = false;

				if (token_text === ',') {
					if (var_line) {
						if (var_line_tainted) {
							print_token();
							print_newline();
							var_line_tainted = false;
						} else {
							print_token();
							print_space();
						}
					} else if (last_type === 'TK_END_BLOCK') {
						print_token();
						print_newline();
					} else {
						if (current_mode === 'BLOCK') {
							print_token();
							print_newline();
						} else {
							// EXPR od DO_BLOCK
							print_token();
							print_space();
						}
					}
					break;
				} else if (token_text === '--' || token_text === '++') { // unary operators special case
					if (last_text === ';') {
						// space for (;; ++i)
						start_delim = true;
						end_delim = false;
					} else {
						start_delim = false;
						end_delim = false;
					}
				} else if (token_text === '!' && last_type === 'TK_START_EXPR') {
					// special case handling: if (!a)
					start_delim = false;
					end_delim = false;
				} else if (last_type === 'TK_OPERATOR') {
					start_delim = false;
					end_delim = false;
				} else if (last_type === 'TK_END_EXPR') {
					start_delim = true;
					end_delim = true;
				} else if (token_text === '.') {
					// decimal digits or object.property
					start_delim = false;
					end_delim = false;

				} else if (token_text === ':') {
					// zz: xx
					// can't differentiate ternary op, so for now it's a ? b: c; without space before colon
					if (last_text.match(/^\d+$/)) {
						// a little help for ternary a ? 1 : 0;
						start_delim = true;
					} else {
						start_delim = false;
					}
				}
				if (start_delim) {
					print_space();
				}

				print_token();

				if (end_delim) {
					print_space();
				}
				break;

			case 'TK_BLOCK_COMMENT':

				print_newline();
				print_token();
				print_newline();
				break;

			case 'TK_COMMENT':

				// print_newline();
				print_space();
				print_token();
				print_newline();
				break;

			case 'TK_UNKNOWN':
				print_token();
				break;
		}

		last_type = token_type;
		last_text = token_text;
	}

	return output.join('');

}
